
import pandas as pd
import numpy as np
import seaborn as sns
from matplotlib import pyplot as plt
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.pipeline import make_pipeline
from sklearn.linear_model import LassoCV
from sklearn.model_selection import GridSearchCV
from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, r2_score
from scipy.stats import entropy


# Importing the cleaned and preprocessed Our World in Data COVID-19 dataset 
df = pd.read_csv("C:/Users/marco/Downloads/covid-data-cleaned.csv")
df


# Showing the pairings of countries based on total population (13 pairs of countries)
df_Austria = df[(df.location == "Austria")]
df_Switzerland = df[(df.location == "Switzerland")]

df_Belgium = df[(df.location == "Belgium")]
df_Canada = df[(df.location == "Canada")]

df_Bulgaria = df[(df.location == "Bulgaria")]
df_Serbia = df[(df.location == "Serbia")]

df_Cyprus = df[(df.location == "Cyprus")]
df_Luxembourg = df[(df.location == "Luxembourg")]

df_Czechia = df[(df.location == "Czechia")]
df_Romania = df[(df.location == "Romania")]

df_Denmark = df[(df.location == "Denmark")]
df_Ireland = df[(df.location == "Ireland")]

df_Estonia = df[(df.location == "Estonia")]
df_Latvia = df[(df.location == "Latvia")]

df_Finland = df[(df.location == "Finland")]
df_Iceland = df[(df.location == "Iceland")]

df_France = df[(df.location == "France")]
df_Italy = df[(df.location == "Italy")]

df_Netherlands = df[(df.location == "Netherlands")]
df_Sweden = df[(df.location == "Sweden")]

df_Portugal = df[(df.location == "Portugal")]
df_Spain = df[(df.location == "Spain")]

df_Slovakia = df[(df.location == "Slovakia")]
df_Slovenia = df[(df.location == "Slovenia")]

df_UnitedKingdom = df[(df.location == "United Kingdom")]
df_UnitedStates = df[(df.location == "United States")]


df_UnitedKingdom_new = df_UnitedKingdom.tail(-2)


# Concatenate individual country dataframes by using the first country from each defined pair above and combining all those countries into a single dataframe
dataframes = [df_Austria, df_Belgium, df_Bulgaria, df_Cyprus, df_Czechia, df_Denmark, df_Estonia, df_Finland, df_France, df_Netherlands, df_Portugal, df_Slovakia, df_UnitedKingdom_new, df_Switzerland, df_Canada, df_Serbia, df_Luxembourg, df_Romania, df_Ireland, df_Latvia, df_Iceland, df_Italy, df_Sweden, df_Spain, df_Slovenia, df_UnitedStates]
dataframe_one = pd.concat(dataframes)

# Exporting final_dataframe to CSV file
dataframe_one.to_csv("dataframe-one.csv")


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_firstCountryPairing = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_firstCountryPairing


country1 = 'Austria'
country2 = 'Switzerland'

# Extracting important features for Random Forest Model Analysis for the population health index
df_firstCountryPairing = df_firstCountryPairing[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_firstCountryPairing = df_firstCountryPairing[df_firstCountryPairing['location'].isin([country1, country2])]


df_firstCountryPairing


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_firstCountryPairing['prev_day_mortality'] = df_firstCountryPairing.groupby(['location'])['Mortality Rate'].shift(1)
df_firstCountryPairing['prev_week_mortality'] = df_firstCountryPairing.groupby(['location'])['Mortality Rate'].shift(7)
df_firstCountryPairing['prev_month_mortality'] = df_firstCountryPairing.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_firstCountryPairing['prev_day_mortality'] = df_firstCountryPairing['prev_day_mortality'].fillna(0)
df_firstCountryPairing['prev_week_mortality'] = df_firstCountryPairing['prev_week_mortality'].fillna(0)
df_firstCountryPairing['prev_month_mortality'] = df_firstCountryPairing['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_firstCountryPairing.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 7 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 7  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_firstCountryPairing.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_firstCountryPairing['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_firstCountryPairing = pd.get_dummies(df_firstCountryPairing, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_firstCountryPairing['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.9989966036956606


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.002337643207376714
R2 Score: 0.9987160137717644
RMSE: 0.048349
Entropy Value: 0.0003719633457117023


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Austria'
country2 = 'Switzerland'

# Extracting important features for Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 5 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 5  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.9989300549094547


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0015429193968664893
R2 Score: 0.9991525279603822
RMSE: 0.039280
Entropy Value: 0.0003132008576474396


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_firstCountryPairing = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_firstCountryPairing


country1 = 'Belgium'
country2 = 'Canada'

# Extracting important features for Random Forest Model Analysis for the population health index
df_firstCountryPairing = df_firstCountryPairing[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_firstCountryPairing = df_firstCountryPairing[df_firstCountryPairing['location'].isin([country1, country2])]


df_firstCountryPairing


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_firstCountryPairing['prev_day_mortality'] = df_firstCountryPairing.groupby(['location'])['Mortality Rate'].shift(1)
df_firstCountryPairing['prev_week_mortality'] = df_firstCountryPairing.groupby(['location'])['Mortality Rate'].shift(7)
df_firstCountryPairing['prev_month_mortality'] = df_firstCountryPairing.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_firstCountryPairing['prev_day_mortality'] = df_firstCountryPairing['prev_day_mortality'].fillna(0)
df_firstCountryPairing['prev_week_mortality'] = df_firstCountryPairing['prev_week_mortality'].fillna(0)
df_firstCountryPairing['prev_month_mortality'] = df_firstCountryPairing['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_firstCountryPairing.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 7 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 7  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_firstCountryPairing.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_firstCountryPairing['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_firstCountryPairing = pd.get_dummies(df_firstCountryPairing, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_firstCountryPairing['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 10, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 100}
Best CV score: 0.9969839146584258


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.041054134347689675
R2 Score: 0.996895600824653
RMSE: 0.202618
Entropy Value: 0.0008300099316689873


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Belgium'
country2 = 'Canada'

# Extracting important features for Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 5 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 5  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 10, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.9974349402891136


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.03575065581898076
R2 Score: 0.9972966350842372
RMSE: 0.189078
Entropy Value: 0.0008915270369744506


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_firstCountryPairing = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_firstCountryPairing


country1 = 'Bulgaria'
country2 = 'Serbia'

# Extracting important features for Random Forest Model Analysis for the population health index
df_firstCountryPairing = df_firstCountryPairing[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_firstCountryPairing = df_firstCountryPairing[df_firstCountryPairing['location'].isin([country1, country2])]


df_firstCountryPairing


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_firstCountryPairing['prev_day_mortality'] = df_firstCountryPairing.groupby(['location'])['Mortality Rate'].shift(1)
df_firstCountryPairing['prev_week_mortality'] = df_firstCountryPairing.groupby(['location'])['Mortality Rate'].shift(7)
df_firstCountryPairing['prev_month_mortality'] = df_firstCountryPairing.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_firstCountryPairing['prev_day_mortality'] = df_firstCountryPairing['prev_day_mortality'].fillna(0)
df_firstCountryPairing['prev_week_mortality'] = df_firstCountryPairing['prev_week_mortality'].fillna(0)
df_firstCountryPairing['prev_month_mortality'] = df_firstCountryPairing['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_firstCountryPairing.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 7 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 7  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_firstCountryPairing.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_firstCountryPairing['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_firstCountryPairing = pd.get_dummies(df_firstCountryPairing, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_firstCountryPairing['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 2, 'min_samples_split': 2, 'n_estimators': 100}
Best CV score: 0.9583831913274017


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.005568712809238791
R2 Score: 0.99727493711111
RMSE: 0.074624
Entropy Value: 0.000639391380225498


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Bulgaria'
country2 = 'Serbia'

# Extracting important features for Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 5 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 5  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 10, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.9565151571739534


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.006760468873536101
R2 Score: 0.9966917484399258
RMSE: 0.082222
Entropy Value: 0.000440139151045257


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_firstCountryPairing = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_firstCountryPairing


country1 = 'Cyprus'
country2 = 'Luxembourg'

# Extracting important features for Random Forest Model Analysis for the population health index
df_firstCountryPairing = df_firstCountryPairing[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_firstCountryPairing = df_firstCountryPairing[df_firstCountryPairing['location'].isin([country1, country2])]


df_firstCountryPairing


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_firstCountryPairing['prev_day_mortality'] = df_firstCountryPairing.groupby(['location'])['Mortality Rate'].shift(1)
df_firstCountryPairing['prev_week_mortality'] = df_firstCountryPairing.groupby(['location'])['Mortality Rate'].shift(7)
df_firstCountryPairing['prev_month_mortality'] = df_firstCountryPairing.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_firstCountryPairing['prev_day_mortality'] = df_firstCountryPairing['prev_day_mortality'].fillna(0)
df_firstCountryPairing['prev_week_mortality'] = df_firstCountryPairing['prev_week_mortality'].fillna(0)
df_firstCountryPairing['prev_month_mortality'] = df_firstCountryPairing['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_firstCountryPairing.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 7 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 7  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_firstCountryPairing.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_firstCountryPairing['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_firstCountryPairing = pd.get_dummies(df_firstCountryPairing, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_firstCountryPairing['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.9919358488759082


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0010130224723005955
R2 Score: 0.997337568618319
RMSE: 0.031828
Entropy Value: 0.00045829706608428716


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Cyprus'
country2 = 'Luxembourg'

# Extracting important features for Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 5 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 5  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.9884045961442933


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0008681898404388339
R2 Score: 0.9977182185591683
RMSE: 0.029465
Entropy Value: 0.00034460747180680264


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_firstCountryPairing = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_firstCountryPairing


country1 = 'Czechia'
country2 = 'Romania'

# Extracting important features for Random Forest Model Analysis for the population health index
df_firstCountryPairing = df_firstCountryPairing[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_firstCountryPairing = df_firstCountryPairing[df_firstCountryPairing['location'].isin([country1, country2])]


df_firstCountryPairing


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_firstCountryPairing['prev_day_mortality'] = df_firstCountryPairing.groupby(['location'])['Mortality Rate'].shift(1)
df_firstCountryPairing['prev_week_mortality'] = df_firstCountryPairing.groupby(['location'])['Mortality Rate'].shift(7)
df_firstCountryPairing['prev_month_mortality'] = df_firstCountryPairing.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_firstCountryPairing['prev_day_mortality'] = df_firstCountryPairing['prev_day_mortality'].fillna(0)
df_firstCountryPairing['prev_week_mortality'] = df_firstCountryPairing['prev_week_mortality'].fillna(0)
df_firstCountryPairing['prev_month_mortality'] = df_firstCountryPairing['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_firstCountryPairing.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 7 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 7  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_firstCountryPairing.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_firstCountryPairing['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_firstCountryPairing = pd.get_dummies(df_firstCountryPairing, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_firstCountryPairing['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.9954484396430019


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.00747804703817538
R2 Score: 0.9948675599333417
RMSE: 0.086476
Entropy Value: 0.0006442605230367055


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Czechia'
country2 = 'Romania'

# Extracting important features for Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 5 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 5  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 10, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 50}
Best CV score: 0.9968976083567679


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.006146149886833695
R2 Score: 0.9957816866123151
RMSE: 0.078397
Entropy Value: 0.0005517608195709189


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_firstCountryPairing = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_firstCountryPairing


country1 = 'Denmark'
country2 = 'Ireland'

# Extracting important features for Random Forest Model Analysis for the population health index
df_firstCountryPairing = df_firstCountryPairing[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_firstCountryPairing = df_firstCountryPairing[df_firstCountryPairing['location'].isin([country1, country2])]


df_firstCountryPairing


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_firstCountryPairing['prev_day_mortality'] = df_firstCountryPairing.groupby(['location'])['Mortality Rate'].shift(1)
df_firstCountryPairing['prev_week_mortality'] = df_firstCountryPairing.groupby(['location'])['Mortality Rate'].shift(7)
df_firstCountryPairing['prev_month_mortality'] = df_firstCountryPairing.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_firstCountryPairing['prev_day_mortality'] = df_firstCountryPairing['prev_day_mortality'].fillna(0)
df_firstCountryPairing['prev_week_mortality'] = df_firstCountryPairing['prev_week_mortality'].fillna(0)
df_firstCountryPairing['prev_month_mortality'] = df_firstCountryPairing['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_firstCountryPairing.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 7 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 7  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_firstCountryPairing.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_firstCountryPairing['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_firstCountryPairing = pd.get_dummies(df_firstCountryPairing, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_firstCountryPairing['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.9979884469227974


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.005995659189568175
R2 Score: 0.9977638141467456
RMSE: 0.077432
Entropy Value: 0.0012403023391896217


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Denmark'
country2 = 'Ireland'

# Extracting important features for Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 5 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 5  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 10, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 100}
Best CV score: 0.9981483428520672


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.007388200063707959
R2 Score: 0.9972444416967158
RMSE: 0.085955
Entropy Value: 0.00131007217788142


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_firstCountryPairing = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_firstCountryPairing


country1 = 'Estonia'
country2 = 'Latvia'

# Extracting important features for Random Forest Model Analysis for the population health index
df_firstCountryPairing = df_firstCountryPairing[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_firstCountryPairing = df_firstCountryPairing[df_firstCountryPairing['location'].isin([country1, country2])]


df_firstCountryPairing


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_firstCountryPairing['prev_day_mortality'] = df_firstCountryPairing.groupby(['location'])['Mortality Rate'].shift(1)
df_firstCountryPairing['prev_week_mortality'] = df_firstCountryPairing.groupby(['location'])['Mortality Rate'].shift(7)
df_firstCountryPairing['prev_month_mortality'] = df_firstCountryPairing.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_firstCountryPairing['prev_day_mortality'] = df_firstCountryPairing['prev_day_mortality'].fillna(0)
df_firstCountryPairing['prev_week_mortality'] = df_firstCountryPairing['prev_week_mortality'].fillna(0)
df_firstCountryPairing['prev_month_mortality'] = df_firstCountryPairing['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_firstCountryPairing.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 7 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 7  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_firstCountryPairing.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_firstCountryPairing['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_firstCountryPairing = pd.get_dummies(df_firstCountryPairing, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_firstCountryPairing['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 100}
Best CV score: 0.9979817144366736


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0018696016902774828
R2 Score: 0.9968998375395624
RMSE: 0.043239
Entropy Value: 0.0007273351883650379


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Estonia'
country2 = 'Latvia'

# Extracting important features for Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 5 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 5  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.9975189433093143


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.002613839817756454
R2 Score: 0.9956657462802128
RMSE: 0.051126
Entropy Value: 0.0010067130210343615


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_firstCountryPairing = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_firstCountryPairing


country1 = 'Finland'
country2 = 'Iceland'

# Extracting important features for Random Forest Model Analysis for the population health index
df_firstCountryPairing = df_firstCountryPairing[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_firstCountryPairing = df_firstCountryPairing[df_firstCountryPairing['location'].isin([country1, country2])]


df_firstCountryPairing


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_firstCountryPairing['prev_day_mortality'] = df_firstCountryPairing.groupby(['location'])['Mortality Rate'].shift(1)
df_firstCountryPairing['prev_week_mortality'] = df_firstCountryPairing.groupby(['location'])['Mortality Rate'].shift(7)
df_firstCountryPairing['prev_month_mortality'] = df_firstCountryPairing.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_firstCountryPairing['prev_day_mortality'] = df_firstCountryPairing['prev_day_mortality'].fillna(0)
df_firstCountryPairing['prev_week_mortality'] = df_firstCountryPairing['prev_week_mortality'].fillna(0)
df_firstCountryPairing['prev_month_mortality'] = df_firstCountryPairing['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_firstCountryPairing.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 7 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 7  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_firstCountryPairing.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_firstCountryPairing['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_firstCountryPairing = pd.get_dummies(df_firstCountryPairing, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_firstCountryPairing['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 10, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 100}
Best CV score: 0.9955159123177418


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.003560841308279542
R2 Score: 0.9970021670932279
RMSE: 0.059673
Entropy Value: 0.0011802071599462333


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Finland'
country2 = 'Iceland'

# Extracting important features for Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 5 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 5  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 10, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 100}
Best CV score: 0.9953918346594799


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0030042606321511634
R2 Score: 0.9974707462074646
RMSE: 0.054811
Entropy Value: 0.0010085785334707671


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_firstCountryPairing = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_firstCountryPairing


country1 = 'France'
country2 = 'Italy'

# Extracting important features for Random Forest Model Analysis for the population health index
df_firstCountryPairing = df_firstCountryPairing[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_firstCountryPairing = df_firstCountryPairing[df_firstCountryPairing['location'].isin([country1, country2])]


df_firstCountryPairing


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_firstCountryPairing['prev_day_mortality'] = df_firstCountryPairing.groupby(['location'])['Mortality Rate'].shift(1)
df_firstCountryPairing['prev_week_mortality'] = df_firstCountryPairing.groupby(['location'])['Mortality Rate'].shift(7)
df_firstCountryPairing['prev_month_mortality'] = df_firstCountryPairing.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_firstCountryPairing['prev_day_mortality'] = df_firstCountryPairing['prev_day_mortality'].fillna(0)
df_firstCountryPairing['prev_week_mortality'] = df_firstCountryPairing['prev_week_mortality'].fillna(0)
df_firstCountryPairing['prev_month_mortality'] = df_firstCountryPairing['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_firstCountryPairing.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 7 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 7  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_firstCountryPairing.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_firstCountryPairing['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_firstCountryPairing = pd.get_dummies(df_firstCountryPairing, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_firstCountryPairing['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 10, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.9950840810056313


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.07475212300690831
R2 Score: 0.995997908929556
RMSE: 0.273408
Entropy Value: 0.0007613902551123477


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'France'
country2 = 'Italy'

# Extracting important features for Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 5 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 5  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 5, 'n_estimators': 200}
Best CV score: 0.9949728012103314


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0891388770292683
R2 Score: 0.9952276686007263
RMSE: 0.298561
Entropy Value: 0.0009498782679573481


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_firstCountryPairing = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_firstCountryPairing


country1 = 'Netherlands'
country2 = 'Sweden'

# Extracting important features for Random Forest Model Analysis for the population health index
df_firstCountryPairing = df_firstCountryPairing[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_firstCountryPairing = df_firstCountryPairing[df_firstCountryPairing['location'].isin([country1, country2])]


df_firstCountryPairing


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_firstCountryPairing['prev_day_mortality'] = df_firstCountryPairing.groupby(['location'])['Mortality Rate'].shift(1)
df_firstCountryPairing['prev_week_mortality'] = df_firstCountryPairing.groupby(['location'])['Mortality Rate'].shift(7)
df_firstCountryPairing['prev_month_mortality'] = df_firstCountryPairing.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_firstCountryPairing['prev_day_mortality'] = df_firstCountryPairing['prev_day_mortality'].fillna(0)
df_firstCountryPairing['prev_week_mortality'] = df_firstCountryPairing['prev_week_mortality'].fillna(0)
df_firstCountryPairing['prev_month_mortality'] = df_firstCountryPairing['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_firstCountryPairing.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 7 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 7  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_firstCountryPairing.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_firstCountryPairing['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_firstCountryPairing = pd.get_dummies(df_firstCountryPairing, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_firstCountryPairing['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 100}
Best CV score: 0.9984656768745841


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.010402460269562753
R2 Score: 0.9990051222850926
RMSE: 0.101992
Entropy Value: 0.00040629309095891516


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Netherlands'
country2 = 'Sweden'

# Extracting important features for Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 5 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 5  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 100}
Best CV score: 0.9984950385348217


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.011447944113759524
R2 Score: 0.9989051335756014
RMSE: 0.106995
Entropy Value: 0.0004521099453512048


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_firstCountryPairing = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_firstCountryPairing


country1 = 'Portugal'
country2 = 'Spain'

# Extracting important features for Random Forest Model Analysis for the population health index
df_firstCountryPairing = df_firstCountryPairing[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_firstCountryPairing = df_firstCountryPairing[df_firstCountryPairing['location'].isin([country1, country2])]


df_firstCountryPairing


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_firstCountryPairing['prev_day_mortality'] = df_firstCountryPairing.groupby(['location'])['Mortality Rate'].shift(1)
df_firstCountryPairing['prev_week_mortality'] = df_firstCountryPairing.groupby(['location'])['Mortality Rate'].shift(7)
df_firstCountryPairing['prev_month_mortality'] = df_firstCountryPairing.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_firstCountryPairing['prev_day_mortality'] = df_firstCountryPairing['prev_day_mortality'].fillna(0)
df_firstCountryPairing['prev_week_mortality'] = df_firstCountryPairing['prev_week_mortality'].fillna(0)
df_firstCountryPairing['prev_month_mortality'] = df_firstCountryPairing['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_firstCountryPairing.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 7 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 7  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_firstCountryPairing.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_firstCountryPairing['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_firstCountryPairing = pd.get_dummies(df_firstCountryPairing, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_firstCountryPairing['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 10, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.998521297102364


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.013814747661354383
R2 Score: 0.9974717098839665
RMSE: 0.117536
Entropy Value: 0.0004896303455702192


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Portugal'
country2 = 'Spain'

# Extracting important features for Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 5 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 5  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 50}
Best CV score: 0.9970653272478941


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.028816362882560887
R2 Score: 0.9947262065698224
RMSE: 0.169754
Entropy Value: 0.0011094469817051415


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_firstCountryPairing = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_firstCountryPairing


country1 = 'Slovakia'
country2 = 'Slovenia'

# Extracting important features for Random Forest Model Analysis for the population health index
df_firstCountryPairing = df_firstCountryPairing[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_firstCountryPairing = df_firstCountryPairing[df_firstCountryPairing['location'].isin([country1, country2])]


df_firstCountryPairing


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_firstCountryPairing['prev_day_mortality'] = df_firstCountryPairing.groupby(['location'])['Mortality Rate'].shift(1)
df_firstCountryPairing['prev_week_mortality'] = df_firstCountryPairing.groupby(['location'])['Mortality Rate'].shift(7)
df_firstCountryPairing['prev_month_mortality'] = df_firstCountryPairing.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_firstCountryPairing['prev_day_mortality'] = df_firstCountryPairing['prev_day_mortality'].fillna(0)
df_firstCountryPairing['prev_week_mortality'] = df_firstCountryPairing['prev_week_mortality'].fillna(0)
df_firstCountryPairing['prev_month_mortality'] = df_firstCountryPairing['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_firstCountryPairing.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 7 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 7  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_firstCountryPairing.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_firstCountryPairing['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_firstCountryPairing = pd.get_dummies(df_firstCountryPairing, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_firstCountryPairing['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 10, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 100}
Best CV score: 0.997363058447263


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.004452525636132693
R2 Score: 0.9978154993065472
RMSE: 0.066727
Entropy Value: 0.0005847514751188148


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Slovakia'
country2 = 'Slovenia'

# Extracting important features for Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 5 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 5  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 50}
Best CV score: 0.9972767647444323


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.007179321254382132
R2 Score: 0.9964776772689534
RMSE: 0.084731
Entropy Value: 0.0007774232059793869


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_firstCountryPairing = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_firstCountryPairing


country1 = 'United Kingdom'
country2 = 'United States'

# Extracting important features for Random Forest Model Analysis for the population health index
df_firstCountryPairing = df_firstCountryPairing[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_firstCountryPairing = df_firstCountryPairing[df_firstCountryPairing['location'].isin([country1, country2])]


df_firstCountryPairing


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_firstCountryPairing['prev_day_mortality'] = df_firstCountryPairing.groupby(['location'])['Mortality Rate'].shift(1)
df_firstCountryPairing['prev_week_mortality'] = df_firstCountryPairing.groupby(['location'])['Mortality Rate'].shift(7)
df_firstCountryPairing['prev_month_mortality'] = df_firstCountryPairing.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_firstCountryPairing['prev_day_mortality'] = df_firstCountryPairing['prev_day_mortality'].fillna(0)
df_firstCountryPairing['prev_week_mortality'] = df_firstCountryPairing['prev_week_mortality'].fillna(0)
df_firstCountryPairing['prev_month_mortality'] = df_firstCountryPairing['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_firstCountryPairing.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 7 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 7  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_firstCountryPairing.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_firstCountryPairing['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_firstCountryPairing = pd.get_dummies(df_firstCountryPairing, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_firstCountryPairing['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 10, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.9639563497859113


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.483882915680185
R2 Score: 0.980047429301368
RMSE: 0.695617
Entropy Value: 0.005987538685788008


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'United Kingdom'
country2 = 'United States'

# Extracting important features for Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 5 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 5  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 5, 'n_estimators': 50}
Best CV score: 0.9549424661572783


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.9691062567746922
R2 Score: 0.9600395871063083
RMSE: 0.984432
Entropy Value: 0.008653279765116838


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Country Pair by Pair Analysis relative to cardiovascular death rate


# Importing the cleaned and preprocessed Our World in Data COVID-19 dataset 
df = pd.read_csv("C:/Users/marco/Downloads/covid-data-cleaned.csv")
df


# Showing the pairings of countries based on cardiovascular death rate (13 pairs of countries)
df_Austria = df[(df.location == "Austria")]
df_Belgium = df[(df.location == "Belgium")]

df_Canada = df[(df.location == "Canada")]
df_Cyprus = df[(df.location == "Cyprus")]

df_Denmark = df[(df.location == "Denmark")]
df_Finland = df[(df.location == "Finland")]

df_France = df[(df.location == "France")]
df_Iceland = df[(df.location == "Iceland")]

df_Ireland = df[(df.location == "Ireland")]
df_Italy = df[(df.location == "Italy")]

df_Luxembourg = df[(df.location == "Luxembourg")]
df_Netherlands = df[(df.location == "Netherlands")]

df_Portugal = df[(df.location == "Portugal")]
df_Spain = df[(df.location == "Spain")]

df_Sweden = df[(df.location == "Sweden")]
df_Switzerland = df[(df.location == "Switzerland")]

df_UnitedKingdom = df[(df.location == "United Kingdom")]
df_UnitedStates = df[(df.location == "United States")]

df_Czechia = df[(df.location == "Czechia")]
df_Estonia = df[(df.location == "Estonia")]

df_Slovakia = df[(df.location == "Slovakia")]
df_Slovenia = df[(df.location == "Slovenia")]

df_Bulgaria = df[(df.location == "Bulgaria")]
df_Latvia = df[(df.location == "Latvia")]

df_Romania = df[(df.location == "Romania")]
df_Serbia = df[(df.location == "Serbia")]


df_UnitedKingdom_new = df_UnitedKingdom.tail(-2)


# Concatenate individual country dataframes by using the first country from each defined pair above and combining all those countries into a single dataframe
dataframes = [df_Austria, df_Belgium, df_Bulgaria, df_Cyprus, df_Czechia, df_Denmark, df_Estonia, df_Finland, df_France, df_Netherlands, df_Portugal, df_Slovakia, df_UnitedKingdom_new, df_Switzerland, df_Canada, df_Serbia, df_Luxembourg, df_Romania, df_Ireland, df_Latvia, df_Iceland, df_Italy, df_Sweden, df_Spain, df_Slovenia, df_UnitedStates]
dataframe_one = pd.concat(dataframes)

# Exporting final_dataframe to CSV file
dataframe_one.to_csv("dataframe-one.csv")


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Austria'
country2 = 'Belgium'

# Extracting important features for Random Forest Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 6  # of input variables for the Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 10, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 50}
Best CV score: 0.9982254364422947


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.013887676064707104
R2 Score: 0.998827031715265
RMSE: 0.117846
Entropy Value: 0.0007324096000498459


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Austria'
country2 = 'Belgium'

# Extracting important features for the Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 6  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 50}
Best CV score: 0.9978932925070829


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.008856177569188209
R2 Score: 0.9992519975722188
RMSE: 0.094107
Entropy Value: 0.000433455898033473


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Canada'
country2 = 'Cyprus'

# Extracting important features for Random Forest Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 6  # of input variables for the Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.9983737881892208


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0024167910786875983
R2 Score: 0.9992894760777331
RMSE: 0.049161
Entropy Value: 0.0002770358074043776


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Canada'
country2 = 'Cyprus'

# Extracting important features for the Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 6  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 100}
Best CV score: 0.9989558784228938


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0032162020605789846
R2 Score: 0.9990544534349546
RMSE: 0.056712
Entropy Value: 0.000341364428693161


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Denmark'
country2 = 'Finland'

# Extracting important features for Random Forest Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 6  # of input variables for the Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 100}
Best CV score: 0.9985717047514587


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.007552765911951941
R2 Score: 0.9957154647674932
RMSE: 0.086907
Entropy Value: 0.0014811041103746996


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Denmark'
country2 = 'Finland'

# Extracting important features for the Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 6  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.9989156833724155


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.008329520038950185
R2 Score: 0.995274827461516
RMSE: 0.091266
Entropy Value: 0.0016508456649447665


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'France'
country2 = 'Iceland'

# Extracting important features for Random Forest Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 6  # of input variables for the Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 10, 'min_samples_leaf': 1, 'min_samples_split': 5, 'n_estimators': 100}
Best CV score: 0.9911158420617596


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.12607663768274116
R2 Score: 0.9899744938655387
RMSE: 0.355073
Entropy Value: 0.0030851096784643584


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'France'
country2 = 'Iceland'

# Extracting important features for the Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 6  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 10, 'min_samples_leaf': 1, 'min_samples_split': 5, 'n_estimators': 100}
Best CV score: 0.9906321989356222


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.1263773231369439
R2 Score: 0.9899505836160186
RMSE: 0.355496
Entropy Value: 0.0032779127594959943


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Ireland'
country2 = 'Italy'

# Extracting important features for Random Forest Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 6  # of input variables for the Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.9983164837805587


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.00685068236066425
R2 Score: 0.9994372009296628
RMSE: 0.082769
Entropy Value: 0.0003107010743677336


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Ireland'
country2 = 'Italy'

# Extracting important features for the Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 6  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 10, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.9986413470709365


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.013803653998387413
R2 Score: 0.9988659985635657
RMSE: 0.117489
Entropy Value: 0.0004399732479586434


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Luxembourg'
country2 = 'Netherlands'

# Extracting important features for Random Forest Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 6  # of input variables for the Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.9984742718532862


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.008485613991385917
R2 Score: 0.9988940462273057
RMSE: 0.092117
Entropy Value: 0.0013446805914148691


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Luxembourg'
country2 = 'Netherlands'

# Extracting important features for the Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 6  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 10, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.9985273943931006


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.007512088981123421
R2 Score: 0.9990209284610492
RMSE: 0.086672
Entropy Value: 0.0009194530556352238


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Portugal'
country2 = 'Spain'

# Extracting important features for Random Forest Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 6  # of input variables for the Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 10, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 50}
Best CV score: 0.9974493361773998


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.029155220822653562
R2 Score: 0.9946641908745901
RMSE: 0.170749
Entropy Value: 0.001250556072636702


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Portugal'
country2 = 'Spain'

# Extracting important features for the Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 6  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 50}
Best CV score: 0.9967905002141979


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.02264676574464689
R2 Score: 0.9958553282770057
RMSE: 0.150488
Entropy Value: 0.0008599665585553152


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Sweden'
country2 = 'Switzerland'

# Extracting important features for Random Forest Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 6  # of input variables for the Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.996177252695678


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.026225471602158636
R2 Score: 0.9949896669761966
RMSE: 0.161943
Entropy Value: 0.0011876312272444455


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Sweden'
country2 = 'Switzerland'

# Extracting important features for the Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 6  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.9964944545383589


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.025985308865571106
R2 Score: 0.9950355496702608
RMSE: 0.161200
Entropy Value: 0.0009864073077925806


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'United Kingdom'
country2 = 'United States'

# Extracting important features for Random Forest Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 6  # of input variables for the Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 50}
Best CV score: 0.9638881170030213


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  1.307896296891642
R2 Score: 0.9460698187834822
RMSE: 1.143633
Entropy Value: 0.007993738527703239


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'United Kingdom'
country2 = 'United States'

# Extracting important features for the Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 6  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 10, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 50}
Best CV score: 0.9638248976625985


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.908396956844949
R2 Score: 0.9625428922647679
RMSE: 0.953099
Entropy Value: 0.007020342279931816


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Czechia'
country2 = 'Estonia'

# Extracting important features for Random Forest Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 6  # of input variables for the Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 50}
Best CV score: 0.9976974336489285


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0014714686404337467
R2 Score: 0.9978634041885316
RMSE: 0.038360
Entropy Value: 0.000335000984342334


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Czechia'
country2 = 'Estonia'

# Extracting important features for the Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 6  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.9968447535278674


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0019107375406635276
R2 Score: 0.9972255787761853
RMSE: 0.043712
Entropy Value: 0.0005664584928279815


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Slovakia'
country2 = 'Slovenia'

# Extracting important features for Random Forest Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 6  # of input variables for the Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 50}
Best CV score: 0.9970316226679301


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.007095434014830886
R2 Score: 0.9965188340747636
RMSE: 0.084234
Entropy Value: 0.0009978441951363514


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Slovakia'
country2 = 'Slovenia'

# Extracting important features for the Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 6  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.9967388889181926


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.010420033179699867
R2 Score: 0.9948877173166316
RMSE: 0.102079
Entropy Value: 0.0011192503090849918


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Bulgaria'
country2 = 'Latvia'

# Extracting important features for Random Forest Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 6  # of input variables for the Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 2, 'min_samples_split': 2, 'n_estimators': 100}
Best CV score: 0.9520281114433315


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0034538780402943816
R2 Score: 0.9980017666453213
RMSE: 0.058770
Entropy Value: 0.0005870161018070032


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Bulgaria'
country2 = 'Latvia'

# Extracting important features for the Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 6  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 2, 'min_samples_split': 2, 'n_estimators': 100}
Best CV score: 0.9544889135900533


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0058068592192322644
R2 Score: 0.9966404546882018
RMSE: 0.076203
Entropy Value: 0.000744361683555891


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Romania'
country2 = 'Serbia'

# Extracting important features for Random Forest Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 6  # of input variables for the Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.9965278391641423


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.002681968001128092
R2 Score: 0.9984385356636368
RMSE: 0.051788
Entropy Value: 0.0006055225602219516


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Romania'
country2 = 'Serbia'

# Extracting important features for the Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 6  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.9942151184753699


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.003107698404524249
R2 Score: 0.9981906718406797
RMSE: 0.055747
Entropy Value: 0.0004506715934095217


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Country Pair by Pair Analysis relative to male smokers


# Importing the cleaned and preprocessed Our World in Data COVID-19 dataset 
df = pd.read_csv("C:/Users/marco/Downloads/covid-data-cleaned.csv")
df


# Showing the pairings of countries based on male smokers (13 pairs of countries)
df_Canada = df[(df.location == "Canada")]
df_Denmark = df[(df.location == "Denmark")]

df_Finland = df[(df.location == "Finland")]
df_Iceland = df[(df.location == "Iceland")]

df_Ireland = df[(df.location == "Ireland")]
df_Luxembourg = df[(df.location == "Luxembourg")]

df_Netherlands = df[(df.location == "Netherlands")]
df_Slovenia = df[(df.location == "Slovenia")]

df_Sweden = df[(df.location == "Sweden")]
df_UnitedKingdom = df[(df.location == "United Kingdom")]

df_UnitedStates = df[(df.location == "United States")]
df_Austria = df[(df.location == "Austria")]

df_Belgium = df[(df.location == "Belgium")]
df_Czechia = df[(df.location == "Czechia")]

df_Estonia = df[(df.location == "Estonia")]
df_France = df[(df.location == "France")]

df_Italy = df[(df.location == "Italy")]
df_Portugal = df[(df.location == "Portugal")]

df_Romania = df[(df.location == "Romania")]
df_Serbia = df[(df.location == "Serbia")]

df_Slovakia = df[(df.location == "Slovakia")]
df_Spain = df[(df.location == "Spain")]

df_Switzerland = df[(df.location == "Switzerland")]
df_Bulgaria = df[(df.location == "Bulgaria")]

df_Cyprus = df[(df.location == "Cyprus")]
df_Latvia = df[(df.location == "Latvia")]


df_UnitedKingdom_new = df_UnitedKingdom.tail(-2)


# Concatenate individual country dataframes by using the first country from each defined pair above and combining all those countries into a single dataframe
dataframes = [df_Austria, df_Belgium, df_Bulgaria, df_Cyprus, df_Czechia, df_Denmark, df_Estonia, df_Finland, df_France, df_Netherlands, df_Portugal, df_Slovakia, df_UnitedKingdom_new, df_Switzerland, df_Canada, df_Serbia, df_Luxembourg, df_Romania, df_Ireland, df_Latvia, df_Iceland, df_Italy, df_Sweden, df_Spain, df_Slovenia, df_UnitedStates]
dataframe_one = pd.concat(dataframes)

# Exporting final_dataframe to CSV file
dataframe_one.to_csv("dataframe-one.csv")


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Canada'
country2 = 'Denmark'

# Extracting important features for Random Forest Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 6  # of input variables for the Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 10, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 50}
Best CV score: 0.9985893709741042


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0035792870495897117
R2 Score: 0.999145763988884
RMSE: 0.059827
Entropy Value: 0.0004571636325590867


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Canada'
country2 = 'Denmark'

# Extracting important features for the Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 6  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 10, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.9989520477467734


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0026540444143001835
R2 Score: 0.9993665832657773
RMSE: 0.051517
Entropy Value: 0.00039769797240609057


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Finland'
country2 = 'Iceland'

# Extracting important features for Random Forest Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 6  # of input variables for the Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 100}
Best CV score: 0.9964956178544988


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0032498598374813537
R2 Score: 0.9972639789533597
RMSE: 0.057008
Entropy Value: 0.0008594876046729041


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Finland'
country2 = 'Iceland'

# Extracting important features for the Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 6  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 10, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 50}
Best CV score: 0.9962131899966675


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.002658355780630809
R2 Score: 0.9977619596754977
RMSE: 0.051559
Entropy Value: 0.0007340555943675478


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Ireland'
country2 = 'Luxembourg'

# Extracting important features for Random Forest Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 6  # of input variables for the Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 10, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.9981898039474573


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0024182536451926267
R2 Score: 0.9989409896781432
RMSE: 0.049176
Entropy Value: 0.0004535153217103071


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Ireland'
country2 = 'Luxembourg'

# Extracting important features for the Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 6  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 50}
Best CV score: 0.998351364576265


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.001882911265242772
R2 Score: 0.9991754287359407
RMSE: 0.043393
Entropy Value: 0.0004605212242426924


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Netherlands'
country2 = 'Slovenia'

# Extracting important features for Random Forest Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 6  # of input variables for the Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.9990369085942957


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.004094213219663488
R2 Score: 0.9995002849901965
RMSE: 0.063986
Entropy Value: 0.00025517686621591407


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Netherlands'
country2 = 'Slovenia'

# Extracting important features for the Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 6  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.9989307334211548


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.00559759095128752
R2 Score: 0.9993167917577755
RMSE: 0.074817
Entropy Value: 0.00043829864165291835


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Sweden'
country2 = 'United Kingdom'

# Extracting important features for Random Forest Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 6  # of input variables for the Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 100}
Best CV score: 0.9647620002703616


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.19934385811888447
R2 Score: 0.9926835029165212
RMSE: 0.446479
Entropy Value: 0.002995808129382941


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Sweden'
country2 = 'United Kingdom'

# Extracting important features for the Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 6  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 10, 'min_samples_leaf': 1, 'min_samples_split': 5, 'n_estimators': 100}
Best CV score: 0.9657040062307898


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.1755698880186287
R2 Score: 0.9935560764913614
RMSE: 0.419011
Entropy Value: 0.0030443221086945424


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'United States'
country2 = 'Austria'

# Extracting important features for Random Forest Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 6  # of input variables for the Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 10, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.9707123801174072


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.015612908849576288
R2 Score: 0.9900116946003525
RMSE: 0.124952
Entropy Value: 0.0008956642056999705


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'United States'
country2 = 'Austria'

# Extracting important features for the Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 6  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 10, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 50}
Best CV score: 0.9748898922979944


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.011356761380877888
R2 Score: 0.9927345504853691
RMSE: 0.106568
Entropy Value: 0.0008026741253104213


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Belgium'
country2 = 'Czechia'

# Extracting important features for Random Forest Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 6  # of input variables for the Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 10, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 100}
Best CV score: 0.9981564421259727


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.021770315476854027
R2 Score: 0.9980743421157474
RMSE: 0.147548
Entropy Value: 0.0008394924242857518


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Belgium'
country2 = 'Czechia'

# Extracting important features for the Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 6  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.9981977178578196


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.018443397054300942
R2 Score: 0.9983686192794139
RMSE: 0.135806
Entropy Value: 0.000594716015312401


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Estonia'
country2 = 'France'

# Extracting important features for Random Forest Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 6  # of input variables for the Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 50}
Best CV score: 0.99396874660859


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.09053132731245286
R2 Score: 0.9905744145265692
RMSE: 0.300884
Entropy Value: 0.005811101609293169


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Estonia'
country2 = 'France'

# Extracting important features for the Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 6  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 50}
Best CV score: 0.9924204242316919


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.09564363505394957
R2 Score: 0.9900421513308949
RMSE: 0.309263
Entropy Value: 0.005800126883421082


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Italy'
country2 = 'Portugal'

# Extracting important features for Random Forest Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 6  # of input variables for the Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 10, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 100}
Best CV score: 0.9992491538823527


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.03916584085137451
R2 Score: 0.9965620865525731
RMSE: 0.197904
Entropy Value: 0.0019471953731532649


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Italy'
country2 = 'Portugal'

# Extracting important features for the Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 6  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.9991962488532368


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0346698323414571
R2 Score: 0.996956738825574
RMSE: 0.186198
Entropy Value: 0.0012806717112898633


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Romania'
country2 = 'Serbia'

# Extracting important features for Random Forest Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 6  # of input variables for the Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 50}
Best CV score: 0.9963303624947721


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.002100050408732467
R2 Score: 0.9987773329821902
RMSE: 0.045826
Entropy Value: 0.0002089676106423466


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Romania'
country2 = 'Serbia'

# Extracting important features for the Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 6  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.9942151184753699


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.003107698404524249
R2 Score: 0.9981906718406797
RMSE: 0.055747
Entropy Value: 0.0004506715934095217


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Slovakia'
country2 = 'Spain'

# Extracting important features for Random Forest Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 6  # of input variables for the Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 100}
Best CV score: 0.9993652655177874


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.002584137818108158
R2 Score: 0.9995264678213833
RMSE: 0.050834
Entropy Value: 0.0002068980142316218


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Slovakia'
country2 = 'Spain'

# Extracting important features for the Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 6  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.9975963885456272


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.008134240357790014
R2 Score: 0.9985094353207385
RMSE: 0.090190
Entropy Value: 0.0006655143831412369


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Switzerland'
country2 = 'Bulgaria'

# Extracting important features for Random Forest Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 6  # of input variables for the Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 50}
Best CV score: 0.9590497939781765


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.004896549532936876
R2 Score: 0.9980297240563568
RMSE: 0.069975
Entropy Value: 0.0006950015035866526


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Switzerland'
country2 = 'Bulgaria'

# Extracting important features for the Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 6  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 100}
Best CV score: 0.956167269462329


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.005126255663843806
R2 Score: 0.9979372947935078
RMSE: 0.071598
Entropy Value: 0.0006230810700906027


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Cyprus'
country2 = 'Latvia'

# Extracting important features for Random Forest Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 6  # of input variables for the Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.9920063450501019


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0009323680911373003
R2 Score: 0.9981522797865945
RMSE: 0.030535
Entropy Value: 0.0003241275435360705


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Cyprus'
country2 = 'Latvia'

# Extracting important features for the Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 6  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.9928418947763469


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0007558023623301819
R2 Score: 0.9985021888720862
RMSE: 0.027492
Entropy Value: 0.00025084148640829615


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Country Pair by Pair Analysis relative to female smokers


# Importing the cleaned and preprocessed Our World in Data COVID-19 dataset 
df = pd.read_csv("C:/Users/marco/Downloads/covid-data-cleaned.csv")
df


# Showing the pairings of countries based on female smokers (13 pairs of countries)
df_Canada = df[(df.location == "Canada")]
df_Cyprus = df[(df.location == "Cyprus")]

df_Denmark = df[(df.location == "Denmark")]
df_Finland = df[(df.location == "Finland")]

df_Iceland = df[(df.location == "Iceland")]
df_Italy = df[(df.location == "Italy")]

df_Portugal = df[(df.location == "Portugal")]
df_Slovenia = df[(df.location == "Slovenia")]

df_Sweden = df[(df.location == "Sweden")]
df_UnitedKingdom = df[(df.location == "United Kingdom")]

df_UnitedStates = df[(df.location == "United States")]
df_Austria = df[(df.location == "Austria")]

df_Belgium = df[(df.location == "Belgium")]
df_Estonia = df[(df.location == "Estonia")]

df_Ireland = df[(df.location == "Ireland")]
df_Latvia = df[(df.location == "Latvia")]

df_Luxembourg = df[(df.location == "Luxembourg")]
df_Netherlands = df[(df.location == "Netherlands")]

df_Romania = df[(df.location == "Romania")]
df_Slovakia = df[(df.location == "Slovakia")]

df_Spain = df[(df.location == "Spain")]
df_Switzerland = df[(df.location == "Switzerland")]

df_Bulgaria= df[(df.location == "Bulgaria")]
df_Czechia = df[(df.location == "Czechia")]

df_France = df[(df.location == "France")]
df_Serbia = df[(df.location == "Serbia")]


df_UnitedKingdom_new = df_UnitedKingdom.tail(-2)


# Concatenate individual country dataframes by using the first country from each defined pair above and combining all those countries into a single dataframe
dataframes = [df_Austria, df_Belgium, df_Bulgaria, df_Cyprus, df_Czechia, df_Denmark, df_Estonia, df_Finland, df_France, df_Netherlands, df_Portugal, df_Slovakia, df_UnitedKingdom_new, df_Switzerland, df_Canada, df_Serbia, df_Luxembourg, df_Romania, df_Ireland, df_Latvia, df_Iceland, df_Italy, df_Sweden, df_Spain, df_Slovenia, df_UnitedStates]
dataframe_one = pd.concat(dataframes)

# Exporting final_dataframe to CSV file
dataframe_one.to_csv("dataframe-one.csv")


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Canada'
country2 = 'Cyprus'

# Extracting important features for Random Forest Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 6  # of input variables for the Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 10, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 50}
Best CV score: 0.9982903099276361


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.002818832110675199
R2 Score: 0.9991712781195069
RMSE: 0.053093
Entropy Value: 0.00033073646040135244


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Canada'
country2 = 'Cyprus'

# Extracting important features for the Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 6  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 100}
Best CV score: 0.9989558784228938


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0032162020605789846
R2 Score: 0.9990544534349546
RMSE: 0.056712
Entropy Value: 0.000341364428693161


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Denmark'
country2 = 'Finland'

# Extracting important features for Random Forest Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 6  # of input variables for the Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.9989113781858382


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.008523656273191014
R2 Score: 0.9951646978023675
RMSE: 0.092324
Entropy Value: 0.0017240442447165512


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Denmark'
country2 = 'Finland'

# Extracting important features for the Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 6  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.9989156833724155


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.008329520038950185
R2 Score: 0.995274827461516
RMSE: 0.091266
Entropy Value: 0.0016508456649447665


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Iceland'
country2 = 'Italy'

# Extracting important features for Random Forest Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 6  # of input variables for the Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.9986885167827337


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.025865966557999595
R2 Score: 0.9978789245215064
RMSE: 0.160829
Entropy Value: 0.001439826222505498


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Iceland'
country2 = 'Italy'

# Extracting important features for the Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 6  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.999041254481315


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.020316963384106206
R2 Score: 0.9983339569880426
RMSE: 0.142538
Entropy Value: 0.001115730684759821


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Portugal'
country2 = 'Slovenia'

# Extracting important features for Random Forest Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 6  # of input variables for the Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 10, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.998368534343579


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0031857365835024896
R2 Score: 0.9984052886270314
RMSE: 0.056442
Entropy Value: 0.00046176412460026606


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Portugal'
country2 = 'Slovenia'

# Extracting important features for the Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 6  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 100}
Best CV score: 0.998167144839121


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0038490153568325174
R2 Score: 0.9980732655059875
RMSE: 0.062040
Entropy Value: 0.000510878761187502


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Sweden'
country2 = 'United Kingdom'

# Extracting important features for Random Forest Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 6  # of input variables for the Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 100}
Best CV score: 0.9636756360711152


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.3274210506772977
R2 Score: 0.9879826989155525
RMSE: 0.572207
Entropy Value: 0.0035336135372386534


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Sweden'
country2 = 'United Kingdom'

# Extracting important features for the Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 6  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 10, 'min_samples_leaf': 1, 'min_samples_split': 5, 'n_estimators': 100}
Best CV score: 0.9657040062307898


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.1755698880186287
R2 Score: 0.9935560764913614
RMSE: 0.419011
Entropy Value: 0.0030443221086945424


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'United States'
country2 = 'Austria'

# Extracting important features for Random Forest Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 6  # of input variables for the Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 10, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 50}
Best CV score: 0.9726217165926947


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.011712039224039057
R2 Score: 0.9925072626920814
RMSE: 0.108222
Entropy Value: 0.0007421212804027486


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'United States'
country2 = 'Austria'

# Extracting important features for the Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 6  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 10, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 50}
Best CV score: 0.9748898922979944


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.011356761380877888
R2 Score: 0.9927345504853691
RMSE: 0.106568
Entropy Value: 0.0008026741253104213


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Belgium'
country2 = 'Estonia'

# Extracting important features for Random Forest Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 6  # of input variables for the Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.998306333473295


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.017273039382732797
R2 Score: 0.9986315561079507
RMSE: 0.131427
Entropy Value: 0.000694873976607357


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Belgium'
country2 = 'Estonia'

# Extracting important features for the Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 6  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 10, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.9984095979233917


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.016179009133714634
R2 Score: 0.9987182298530174
RMSE: 0.127197
Entropy Value: 0.0006399632348900017


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Ireland'
country2 = 'Latvia'

# Extracting important features for Random Forest Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 6  # of input variables for the Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.998374045977475


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.003030155883805974
R2 Score: 0.9986252667840227
RMSE: 0.055047
Entropy Value: 0.0004986576827960621


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Ireland'
country2 = 'Latvia'

# Extracting important features for the Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 6  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 50}
Best CV score: 0.9979400711573009


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.004705897262529415
R2 Score: 0.9978650097467429
RMSE: 0.068600
Entropy Value: 0.0007148305943023663


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Luxembourg'
country2 = 'Netherlands'

# Extracting important features for Random Forest Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 6  # of input variables for the Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 10, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.9986500446225092


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.009737687060063437
R2 Score: 0.9987308600470954
RMSE: 0.098680
Entropy Value: 0.001010970627044727


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Luxembourg'
country2 = 'Netherlands'

# Extracting important features for the Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 6  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 10, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.9985273943931006


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.007512088981123421
R2 Score: 0.9990209284610492
RMSE: 0.086672
Entropy Value: 0.0009194530556352238


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Romania'
country2 = 'Slovakia'

# Extracting important features for Random Forest Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 6  # of input variables for the Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.9980209439218296


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0025858758735811936
R2 Score: 0.998541908086158
RMSE: 0.050852
Entropy Value: 0.00025608225493814756


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Romania'
country2 = 'Slovakia'

# Extracting important features for the Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 6  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 10, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.9947150727401987


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0023029360576114406
R2 Score: 0.9987014487129855
RMSE: 0.047989
Entropy Value: 0.00021180348784876973


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Spain'
country2 = 'Switzerland'

# Extracting important features for Random Forest Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 6  # of input variables for the Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.9988894734018896


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.008646276456698085
R2 Score: 0.998600555703449
RMSE: 0.092985
Entropy Value: 0.00042564211305673786


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Spain'
country2 = 'Switzerland'

# Extracting important features for the Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 6  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.9984087201734722


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.009004477715309808
R2 Score: 0.9985425789881667
RMSE: 0.094892
Entropy Value: 0.0005624411655893531


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Bulgaria'
country2 = 'Czechia'

# Extracting important features for Random Forest Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 6  # of input variables for the Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 50}
Best CV score: 0.946009198558348


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0036901120196825726
R2 Score: 0.9977493146946407
RMSE: 0.060746
Entropy Value: 0.00036888555731396776


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Bulgaria'
country2 = 'Czechia'

# Extracting important features for the Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 6  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 10, 'min_samples_leaf': 2, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.9509416306303644


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.003709674750284998
R2 Score: 0.9977373829294084
RMSE: 0.060907
Entropy Value: 0.0006342010482872406


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'France'
country2 = 'Serbia'

# Extracting important features for Random Forest Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 6  # of input variables for the Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 100}
Best CV score: 0.9898468756077163


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.12251771563518532
R2 Score: 0.9894511723406865
RMSE: 0.350025
Entropy Value: 0.0026765662501610065


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'France'
country2 = 'Serbia'

# Extracting important features for the Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 6  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 10, 'min_samples_leaf': 1, 'min_samples_split': 5, 'n_estimators': 100}
Best CV score: 0.9913712149726834


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.14086060776709658
R2 Score: 0.9878718414915131
RMSE: 0.375314
Entropy Value: 0.002701292210197016


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Country Pair by Pair Analysis relative to life expectancy


# Importing the cleaned and preprocessed Our World in Data COVID-19 dataset 
df = pd.read_csv("C:/Users/marco/Downloads/covid-data-cleaned.csv")
df


# Showing the pairings of countries based on life expectancy (13 pairs of countries)
df_Austria = df[(df.location == "Austria")]
df_Belgium = df[(df.location == "Belgium")]

df_Canada = df[(df.location == "Canada")]
df_Cyprus = df[(df.location == "Cyprus")]

df_Denmark = df[(df.location == "Denmark")]
df_Finland = df[(df.location == "Finland")]

df_France = df[(df.location == "France")]
df_Iceland = df[(df.location == "Iceland")]

df_Ireland = df[(df.location == "Ireland")]
df_Italy = df[(df.location == "Italy")]

df_Luxembourg = df[(df.location == "Luxembourg")]
df_Netherlands = df[(df.location == "Netherlands")]

df_Portugal = df[(df.location == "Portugal")]
df_Slovenia = df[(df.location == "Slovenia")]

df_Spain = df[(df.location == "Spain")]
df_Sweden = df[(df.location == "Sweden")]

df_Switzerland = df[(df.location == "Switzerland")]
df_UnitedKingdom = df[(df.location == "United Kingdom")]

df_Czechia = df[(df.location == "Czechia")]
df_Estonia = df[(df.location == "Estonia")]

df_UnitedStates = df[(df.location == "United States")]
df_Bulgaria = df[(df.location == "Bulgaria")]

df_Latvia = df[(df.location == "Latvia")]
df_Romania = df[(df.location == "Romania")]

df_Serbia = df[(df.location == "Serbia")]
df_Slovakia = df[(df.location == "Slovakia")]


df_UnitedKingdom_new = df_UnitedKingdom.tail(-2)


# Concatenate individual country dataframes by using the first country from each defined pair above and combining all those countries into a single dataframe
dataframes = [df_Austria, df_Belgium, df_Bulgaria, df_Cyprus, df_Czechia, df_Denmark, df_Estonia, df_Finland, df_France, df_Netherlands, df_Portugal, df_Slovakia, df_UnitedKingdom_new, df_Switzerland, df_Canada, df_Serbia, df_Luxembourg, df_Romania, df_Ireland, df_Latvia, df_Iceland, df_Italy, df_Sweden, df_Spain, df_Slovenia, df_UnitedStates]
dataframe_one = pd.concat(dataframes)

# Exporting final_dataframe to CSV file
dataframe_one.to_csv("dataframe-one.csv")


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Austria'
country2 = 'Belgium'

# Extracting important features for Random Forest Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 6  # of input variables for the Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 50}
Best CV score: 0.9969932164978618


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.01827006714784305
R2 Score: 0.9984568901791381
RMSE: 0.135167
Entropy Value: 0.0007004294195467055


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Austria'
country2 = 'Belgium'

# Extracting important features for the Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 6  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 50}
Best CV score: 0.9978932925070829


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.008856177569188209
R2 Score: 0.9992519975722188
RMSE: 0.094107
Entropy Value: 0.000433455898033473


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Canada'
country2 = 'Cyprus'

# Extracting important features for Random Forest Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 6  # of input variables for the Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.9982932314972184


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0032838118429310025
R2 Score: 0.9990345765129632
RMSE: 0.057305
Entropy Value: 0.00041277214242018204


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Canada'
country2 = 'Cyprus'

# Extracting important features for the Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 6  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 100}
Best CV score: 0.9989558784228938


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0032162020605789846
R2 Score: 0.9990544534349546
RMSE: 0.056712
Entropy Value: 0.000341364428693161


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Denmark'
country2 = 'Finland'

# Extracting important features for Random Forest Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the population health index
n_components = 6  # of input variables for the Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Instantiate the RandomForestRegressor Model
rf = RandomForestRegressor(n_estimators=100, random_state=42)

# define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
}


# perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=10)
grid_search.fit(X_train_scaled, y_train)

# print best hyperparameters and corresponding mean cross-validation score
print('Best hyperparameters:', grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'max_depth': 15, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200}
Best CV score: 0.9989059824652742


# fit random forest model with best hyperparameters from above
best_rf_model = RandomForestRegressor(n_estimators=grid_search.best_params_['n_estimators'],
                                       max_depth=grid_search.best_params_['max_depth'],
                                       min_samples_split=grid_search.best_params_['min_samples_split'],
                                       min_samples_leaf=grid_search.best_params_['min_samples_leaf'],
                                       random_state=42)
best_rf_model.fit(X_train_scaled, y_train)

y_pred = best_rf_model.predict(X_test_scaled)


# Evaluate the performance of the Random Forest Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.008510747064107163
R2 Score: 0.9951720209422329
RMSE: 0.092254
Entropy Value: 0.0017388182720325979


feature_importances = best_rf_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Denmark'
country2 = 'Finland'

# Extracting important features for the Random Forest Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the Random Forest Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature. A Random Forest model is a type of ensemble learning algorithm that is typically used for non-sequential data.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the Random Forest Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the Random Forest Model Analysis for the country health index
n_components = 6  # of input variables for Random Forest Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for Random Forest Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)

	date	cardiovasc_death_rate	diabetes_prevalence	female_smokers	male_smokers	life_expectancy	aged_65_older	aged_70_older	median_age	hospital_beds_per_thousand	human_development_index	extreme_poverty	gdp_per_capita	population_density	population	stringency_index	Mortality Rate	location
0	2/25/2020	145.183	6.35	28.4	30.9	81.54	19.202	13.748	44.4	7.37	0.922	0.7	45436.686	106.749	8939617	11.11	0.000000	Austria
1	2/26/2020	145.183	6.35	28.4	30.9	81.54	19.202	13.748	44.4	7.37	0.922	0.7	45436.686	106.749	8939617	11.11	0.000000	Austria
2	2/27/2020	145.183	6.35	28.4	30.9	81.54	19.202	13.748	44.4	7.37	0.922	0.7	45436.686	106.749	8939617	11.11	0.000000	Austria
3	2/28/2020	145.183	6.35	28.4	30.9	81.54	19.202	13.748	44.4	7.37	0.922	0.7	45436.686	106.749	8939617	11.11	0.000000	Austria
4	2/29/2020	145.183	6.35	28.4	30.9	81.54	19.202	13.748	44.4	7.37	0.922	0.7	45436.686	106.749	8939617	11.11	0.000000	Austria
...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...
27269	12/25/2022	151.089	10.79	19.1	24.6	78.86	15.413	9.732	38.3	2.77	0.926	1.2	54225.446	35.608	338289856	23.18	1.086136	United States
27270	12/26/2022	151.089	10.79	19.1	24.6	78.86	15.413	9.732	38.3	2.77	0.926	1.2	54225.446	35.608	338289856	23.18	1.086032	United States
27271	12/27/2022	151.089	10.79	19.1	24.6	78.86	15.413	9.732	38.3	2.77	0.926	1.2	54225.446	35.608	338289856	23.18	1.085212	United States
27272	12/28/2022	151.089	10.79	19.1	24.6	78.86	15.413	9.732	38.3	2.77	0.926	1.2	54225.446	35.608	338289856	23.18	1.084986	United States
27273	12/29/2022	151.089	10.79	19.1	24.6	78.86	15.413	9.732	38.3	2.77	0.926	1.2	54225.446	35.608	338289856	23.18	1.084791	United States

	date	cardiovasc_death_rate	diabetes_prevalence	female_smokers	male_smokers	life_expectancy	aged_65_older	aged_70_older	median_age	hospital_beds_per_thousand	human_development_index	extreme_poverty	gdp_per_capita	population_density	population	Mortality Rate	location
0	2/25/2020	145.183	6.35	28.4	30.9	81.54	19.202	13.748	44.4	7.37	0.922	0.7	45436.686	106.749	8939617	0.000000	Austria
1	2/26/2020	145.183	6.35	28.4	30.9	81.54	19.202	13.748	44.4	7.37	0.922	0.7	45436.686	106.749	8939617	0.000000	Austria
2	2/27/2020	145.183	6.35	28.4	30.9	81.54	19.202	13.748	44.4	7.37	0.922	0.7	45436.686	106.749	8939617	0.000000	Austria
3	2/28/2020	145.183	6.35	28.4	30.9	81.54	19.202	13.748	44.4	7.37	0.922	0.7	45436.686	106.749	8939617	0.000000	Austria
4	2/29/2020	145.183	6.35	28.4	30.9	81.54	19.202	13.748	44.4	7.37	0.922	0.7	45436.686	106.749	8939617	0.000000	Austria
...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...
27267	12/25/2022	151.089	10.79	19.1	24.6	78.86	15.413	9.732	38.3	2.77	0.926	1.2	54225.446	35.608	338289856	1.086136	United States
27268	12/26/2022	151.089	10.79	19.1	24.6	78.86	15.413	9.732	38.3	2.77	0.926	1.2	54225.446	35.608	338289856	1.086032	United States
27269	12/27/2022	151.089	10.79	19.1	24.6	78.86	15.413	9.732	38.3	2.77	0.926	1.2	54225.446	35.608	338289856	1.085212	United States
27270	12/28/2022	151.089	10.79	19.1	24.6	78.86	15.413	9.732	38.3	2.77	0.926	1.2	54225.446	35.608	338289856	1.084986	United States
27271	12/29/2022	151.089	10.79	19.1	24.6	78.86	15.413	9.732	38.3	2.77	0.926	1.2	54225.446	35.608	338289856	1.084791	United States

	location	date	cardiovasc_death_rate	diabetes_prevalence	female_smokers	male_smokers	life_expectancy	aged_65_older	median_age	Mortality Rate
0	Austria	2/25/2020	145.183	6.35	28.4	30.9	81.54	19.202	44.4	0.000000
1	Austria	2/26/2020	145.183	6.35	28.4	30.9	81.54	19.202	44.4	0.000000
2	Austria	2/27/2020	145.183	6.35	28.4	30.9	81.54	19.202	44.4	0.000000
3	Austria	2/28/2020	145.183	6.35	28.4	30.9	81.54	19.202	44.4	0.000000
4	Austria	2/29/2020	145.183	6.35	28.4	30.9	81.54	19.202	44.4	0.000000
...	...	...	...	...	...	...	...	...	...	...
14644	Switzerland	12/25/2022	99.739	5.59	22.6	28.9	83.78	18.436	43.1	0.322922
14645	Switzerland	12/26/2022	99.739	5.59	22.6	28.9	83.78	18.436	43.1	0.322922
14646	Switzerland	12/27/2022	99.739	5.59	22.6	28.9	83.78	18.436	43.1	0.322922
14647	Switzerland	12/28/2022	99.739	5.59	22.6	28.9	83.78	18.436	43.1	0.323082
14648	Switzerland	12/29/2022	99.739	5.59	22.6	28.9	83.78	18.436	43.1	0.322149

	date	cardiovasc_death_rate	diabetes_prevalence	female_smokers	male_smokers	life_expectancy	aged_65_older	aged_70_older	median_age	hospital_beds_per_thousand	human_development_index	extreme_poverty	gdp_per_capita	population_density	population	Mortality Rate	location
0	2/25/2020	145.183	6.35	28.4	30.9	81.54	19.202	13.748	44.4	7.37	0.922	0.7	45436.686	106.749	8939617	0.000000	Austria
1	2/26/2020	145.183	6.35	28.4	30.9	81.54	19.202	13.748	44.4	7.37	0.922	0.7	45436.686	106.749	8939617	0.000000	Austria
2	2/27/2020	145.183	6.35	28.4	30.9	81.54	19.202	13.748	44.4	7.37	0.922	0.7	45436.686	106.749	8939617	0.000000	Austria
3	2/28/2020	145.183	6.35	28.4	30.9	81.54	19.202	13.748	44.4	7.37	0.922	0.7	45436.686	106.749	8939617	0.000000	Austria
4	2/29/2020	145.183	6.35	28.4	30.9	81.54	19.202	13.748	44.4	7.37	0.922	0.7	45436.686	106.749	8939617	0.000000	Austria
...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...
27267	12/25/2022	151.089	10.79	19.1	24.6	78.86	15.413	9.732	38.3	2.77	0.926	1.2	54225.446	35.608	338289856	1.086136	United States
27268	12/26/2022	151.089	10.79	19.1	24.6	78.86	15.413	9.732	38.3	2.77	0.926	1.2	54225.446	35.608	338289856	1.086032	United States
27269	12/27/2022	151.089	10.79	19.1	24.6	78.86	15.413	9.732	38.3	2.77	0.926	1.2	54225.446	35.608	338289856	1.085212	United States
27270	12/28/2022	151.089	10.79	19.1	24.6	78.86	15.413	9.732	38.3	2.77	0.926	1.2	54225.446	35.608	338289856	1.084986	United States
27271	12/29/2022	151.089	10.79	19.1	24.6	78.86	15.413	9.732	38.3	2.77	0.926	1.2	54225.446	35.608	338289856	1.084791	United States

	location	date	hospital_beds_per_thousand	human_development_index	extreme_poverty	gdp_per_capita	population_density	Mortality Rate
0	Austria	2/25/2020	7.37	0.922	0.70	45436.686	106.749	0.000000
1	Austria	2/26/2020	7.37	0.922	0.70	45436.686	106.749	0.000000
2	Austria	2/27/2020	7.37	0.922	0.70	45436.686	106.749	0.000000
3	Austria	2/28/2020	7.37	0.922	0.70	45436.686	106.749	0.000000
4	Austria	2/29/2020	7.37	0.922	0.70	45436.686	106.749	0.000000
...	...	...	...	...	...	...	...	...
14644	Switzerland	12/25/2022	4.53	0.955	0.03	57410.166	214.243	0.322922
14645	Switzerland	12/26/2022	4.53	0.955	0.03	57410.166	214.243	0.322922
14646	Switzerland	12/27/2022	4.53	0.955	0.03	57410.166	214.243	0.322922
14647	Switzerland	12/28/2022	4.53	0.955	0.03	57410.166	214.243	0.323082
14648	Switzerland	12/29/2022	4.53	0.955	0.03	57410.166	214.243	0.322149

	feature	importance
1	diabetes_prevalence	0.943736
6	median_age	0.039143
2	female_smokers	0.012458
3	male_smokers	0.001942
0	cardiovasc_death_rate	0.001906
5	aged_65_older	0.000619
4	life_expectancy	0.000196

	feature	importance
1	human_development_index	0.974799
2	extreme_poverty	0.022650
3	gdp_per_capita	0.001858
0	hospital_beds_per_thousand	0.000376
4	population_density	0.000317

	location	date	cardiovasc_death_rate	diabetes_prevalence	female_smokers	male_smokers	life_expectancy	aged_65_older	median_age	Mortality Rate
1039	Belgium	2/4/2020	114.898	4.29	25.1	31.4	81.63	18.571	41.8	0.000000
1040	Belgium	2/5/2020	114.898	4.29	25.1	31.4	81.63	18.571	41.8	0.000000
1041	Belgium	2/6/2020	114.898	4.29	25.1	31.4	81.63	18.571	41.8	0.000000
1042	Belgium	2/7/2020	114.898	4.29	25.1	31.4	81.63	18.571	41.8	0.000000
1043	Belgium	2/8/2020	114.898	4.29	25.1	31.4	81.63	18.571	41.8	0.000000
...	...	...	...	...	...	...	...	...	...	...
15716	Canada	12/25/2022	105.599	7.37	12.0	16.6	82.43	16.984	41.4	1.092509
15717	Canada	12/26/2022	105.599	7.37	12.0	16.6	82.43	16.984	41.4	1.092338
15718	Canada	12/27/2022	105.599	7.37	12.0	16.6	82.43	16.984	41.4	1.092196
15719	Canada	12/28/2022	105.599	7.37	12.0	16.6	82.43	16.984	41.4	1.092321
15720	Canada	12/29/2022	105.599	7.37	12.0	16.6	82.43	16.984	41.4	1.093162

	feature	importance
1	diabetes_prevalence	0.902614
0	cardiovasc_death_rate	0.058815
2	female_smokers	0.024297
5	aged_65_older	0.006879
6	median_age	0.005122
3	male_smokers	0.001783
4	life_expectancy	0.000490

	feature	importance
1	human_development_index	0.944229
0	hospital_beds_per_thousand	0.030624
2	extreme_poverty	0.022911
3	gdp_per_capita	0.001623
4	population_density	0.000613

	location	date	cardiovasc_death_rate	diabetes_prevalence	female_smokers	male_smokers	life_expectancy	aged_65_older	median_age	Mortality Rate
2099	Bulgaria	3/8/2020	424.688	5.81	30.1	44.4	75.05	20.801	44.7	0.000000
2100	Bulgaria	3/9/2020	424.688	5.81	30.1	44.4	75.05	20.801	44.7	0.000000
2101	Bulgaria	3/10/2020	424.688	5.81	30.1	44.4	75.05	20.801	44.7	0.000000
2102	Bulgaria	3/11/2020	424.688	5.81	30.1	44.4	75.05	20.801	44.7	14.285714
2103	Bulgaria	3/12/2020	424.688	5.81	30.1	44.4	75.05	20.801	44.7	14.285714
...	...	...	...	...	...	...	...	...	...	...
16754	Serbia	12/25/2022	439.415	10.08	37.7	40.2	76.00	17.366	41.2	0.717058
16755	Serbia	12/26/2022	439.415	10.08	37.7	40.2	76.00	17.366	41.2	0.716963
16756	Serbia	12/27/2022	439.415	10.08	37.7	40.2	76.00	17.366	41.2	0.716677
16757	Serbia	12/28/2022	439.415	10.08	37.7	40.2	76.00	17.366	41.2	0.716395
16758	Serbia	12/29/2022	439.415	10.08	37.7	40.2	76.00	17.366	41.2	0.716205

	feature	importance
0	cardiovasc_death_rate	0.809015
5	aged_65_older	0.109960
2	female_smokers	0.032594
3	male_smokers	0.025727
1	diabetes_prevalence	0.016079
4	life_expectancy	0.005342
6	median_age	0.001282

	feature	importance
0	hospital_beds_per_thousand	0.764675
1	human_development_index	0.156947
2	extreme_poverty	0.037875
3	gdp_per_capita	0.026132
4	population_density	0.014372

	location	date	cardiovasc_death_rate	diabetes_prevalence	female_smokers	male_smokers	life_expectancy	aged_65_older	median_age	Mortality Rate
3126	Cyprus	3/8/2020	141.171	9.24	19.6	52.7	80.98	13.416	37.3	0.000000
3127	Cyprus	3/9/2020	141.171	9.24	19.6	52.7	80.98	13.416	37.3	0.000000
3128	Cyprus	3/10/2020	141.171	9.24	19.6	52.7	80.98	13.416	37.3	0.000000
3129	Cyprus	3/11/2020	141.171	9.24	19.6	52.7	80.98	13.416	37.3	0.000000
3130	Cyprus	3/12/2020	141.171	9.24	19.6	52.7	80.98	13.416	37.3	0.000000
...	...	...	...	...	...	...	...	...	...	...
17795	Luxembourg	12/25/2022	128.275	4.42	20.9	26.0	82.25	14.312	39.7	0.377872
17796	Luxembourg	12/26/2022	128.275	4.42	20.9	26.0	82.25	14.312	39.7	0.377872
17797	Luxembourg	12/27/2022	128.275	4.42	20.9	26.0	82.25	14.312	39.7	0.377872
17798	Luxembourg	12/28/2022	128.275	4.42	20.9	26.0	82.25	14.312	39.7	0.377872
17799	Luxembourg	12/29/2022	128.275	4.42	20.9	26.0	82.25	14.312	39.7	0.377872

	feature	importance
1	diabetes_prevalence	0.795629
0	cardiovasc_death_rate	0.146630
2	female_smokers	0.035997
5	aged_65_older	0.010106
3	male_smokers	0.005179
6	median_age	0.003941
4	life_expectancy	0.002516

	location	date	cardiovasc_death_rate	diabetes_prevalence	female_smokers	male_smokers	life_expectancy	aged_65_older	median_age	Mortality Rate
4153	Czechia	3/1/2020	227.485	6.82	30.5	38.3	79.38	19.027	43.3	0.000000
4154	Czechia	3/2/2020	227.485	6.82	30.5	38.3	79.38	19.027	43.3	0.000000
4155	Czechia	3/3/2020	227.485	6.82	30.5	38.3	79.38	19.027	43.3	0.000000
4156	Czechia	3/4/2020	227.485	6.82	30.5	38.3	79.38	19.027	43.3	0.000000
4157	Czechia	3/5/2020	227.485	6.82	30.5	38.3	79.38	19.027	43.3	0.000000
...	...	...	...	...	...	...	...	...	...	...
18833	Romania	12/25/2022	370.946	9.74	22.9	37.1	76.05	17.850	43.0	2.037520
18834	Romania	12/26/2022	370.946	9.74	22.9	37.1	76.05	17.850	43.0	2.036403
18835	Romania	12/27/2022	370.946	9.74	22.9	37.1	76.05	17.850	43.0	2.036403
18836	Romania	12/28/2022	370.946	9.74	22.9	37.1	76.05	17.850	43.0	2.036403
18837	Romania	12/29/2022	370.946	9.74	22.9	37.1	76.05	17.850	43.0	2.036403

	location	date	hospital_beds_per_thousand	human_development_index	extreme_poverty	gdp_per_capita	population_density	Mortality Rate
4153	Czechia	3/1/2020	6.630	0.900	0.0	32605.906	137.176	0.000000
4154	Czechia	3/2/2020	6.630	0.900	0.0	32605.906	137.176	0.000000
4155	Czechia	3/3/2020	6.630	0.900	0.0	32605.906	137.176	0.000000
4156	Czechia	3/4/2020	6.630	0.900	0.0	32605.906	137.176	0.000000
4157	Czechia	3/5/2020	6.630	0.900	0.0	32605.906	137.176	0.000000
...	...	...	...	...	...	...	...	...
18833	Romania	12/25/2022	6.892	0.828	5.7	23313.199	85.129	2.037520
18834	Romania	12/26/2022	6.892	0.828	5.7	23313.199	85.129	2.036403
18835	Romania	12/27/2022	6.892	0.828	5.7	23313.199	85.129	2.036403
18836	Romania	12/28/2022	6.892	0.828	5.7	23313.199	85.129	2.036403
18837	Romania	12/29/2022	6.892	0.828	5.7	23313.199	85.129	2.036403

	location	date	cardiovasc_death_rate	diabetes_prevalence	female_smokers	male_smokers	life_expectancy	aged_65_older	median_age	Mortality Rate
5187	Denmark	2/2/2020	114.767	6.41	19.3	18.8	80.9	19.677	42.3	0.000000
5188	Denmark	2/3/2020	114.767	6.41	19.3	18.8	80.9	19.677	42.3	0.000000
5189	Denmark	2/4/2020	114.767	6.41	19.3	18.8	80.9	19.677	42.3	0.000000
5190	Denmark	2/5/2020	114.767	6.41	19.3	18.8	80.9	19.677	42.3	0.000000
5191	Denmark	2/6/2020	114.767	6.41	19.3	18.8	80.9	19.677	42.3	0.000000
...	...	...	...	...	...	...	...	...	...	...
19868	Ireland	12/25/2022	126.459	3.28	23.0	25.7	82.3	13.928	38.7	0.491388
19869	Ireland	12/26/2022	126.459	3.28	23.0	25.7	82.3	13.928	38.7	0.491388
19870	Ireland	12/27/2022	126.459	3.28	23.0	25.7	82.3	13.928	38.7	0.491388
19871	Ireland	12/28/2022	126.459	3.28	23.0	25.7	82.3	13.928	38.7	0.491388
19872	Ireland	12/29/2022	126.459	3.28	23.0	25.7	82.3	13.928	38.7	0.491388

	location	date	hospital_beds_per_thousand	human_development_index	extreme_poverty	gdp_per_capita	population_density	Mortality Rate
5187	Denmark	2/2/2020	2.50	0.940	0.2	46682.515	136.520	0.000000
5188	Denmark	2/3/2020	2.50	0.940	0.2	46682.515	136.520	0.000000
5189	Denmark	2/4/2020	2.50	0.940	0.2	46682.515	136.520	0.000000
5190	Denmark	2/5/2020	2.50	0.940	0.2	46682.515	136.520	0.000000
5191	Denmark	2/6/2020	2.50	0.940	0.2	46682.515	136.520	0.000000
...	...	...	...	...	...	...	...	...
19868	Ireland	12/25/2022	2.96	0.955	0.2	67335.293	69.874	0.491388
19869	Ireland	12/26/2022	2.96	0.955	0.2	67335.293	69.874	0.491388
19870	Ireland	12/27/2022	2.96	0.955	0.2	67335.293	69.874	0.491388
19871	Ireland	12/28/2022	2.96	0.955	0.2	67335.293	69.874	0.491388
19872	Ireland	12/29/2022	2.96	0.955	0.2	67335.293	69.874	0.491388

	feature	importance
1	human_development_index	0.906843
2	extreme_poverty	0.047073
0	hospital_beds_per_thousand	0.033660
3	gdp_per_capita	0.009333
4	population_density	0.003090

	feature	importance
0	cardiovasc_death_rate	0.835149
1	diabetes_prevalence	0.111452
2	female_smokers	0.020746
6	median_age	0.020522
5	aged_65_older	0.008818
3	male_smokers	0.002733
4	life_expectancy	0.000580

	feature	importance
1	human_development_index	0.739105
0	hospital_beds_per_thousand	0.221891
2	extreme_poverty	0.032045
3	gdp_per_capita	0.005941
4	population_density	0.001018

	feature	importance
1	diabetes_prevalence	0.826356
0	cardiovasc_death_rate	0.143178
2	female_smokers	0.015810
6	median_age	0.007248
3	male_smokers	0.004191
5	aged_65_older	0.002957
4	life_expectancy	0.000260

	feature	importance
1	human_development_index	0.956110
0	hospital_beds_per_thousand	0.023453
2	extreme_poverty	0.016011
3	gdp_per_capita	0.003906
4	population_density	0.000520

	location	date	cardiovasc_death_rate	diabetes_prevalence	female_smokers	male_smokers	life_expectancy	aged_65_older	median_age	Mortality Rate
6249	Estonia	1/6/2020	255.569	4.02	24.5	39.3	78.74	19.452	42.7	0.000000
6250	Estonia	1/18/2020	255.569	4.02	24.5	39.3	78.74	19.452	42.7	0.000000
6251	Estonia	2/5/2020	255.569	4.02	24.5	39.3	78.74	19.452	42.7	0.000000
6252	Estonia	2/6/2020	255.569	4.02	24.5	39.3	78.74	19.452	42.7	0.000000
6253	Estonia	2/7/2020	255.569	4.02	24.5	39.3	78.74	19.452	42.7	0.000000
...	...	...	...	...	...	...	...	...	...	...
20906	Latvia	12/25/2022	350.060	4.91	25.6	51.0	75.29	19.754	43.9	0.631631
20907	Latvia	12/26/2022	350.060	4.91	25.6	51.0	75.29	19.754	43.9	0.631631
20908	Latvia	12/27/2022	350.060	4.91	25.6	51.0	75.29	19.754	43.9	0.631485
20909	Latvia	12/28/2022	350.060	4.91	25.6	51.0	75.29	19.754	43.9	0.631485
20910	Latvia	12/29/2022	350.060	4.91	25.6	51.0	75.29	19.754	43.9	0.631969

	feature	importance
1	diabetes_prevalence	0.954112
2	female_smokers	0.017664
0	cardiovasc_death_rate	0.012118
5	aged_65_older	0.010583
6	median_age	0.004349
3	male_smokers	0.000941
4	life_expectancy	0.000232

	feature	importance
1	human_development_index	0.960216
2	extreme_poverty	0.023054
0	hospital_beds_per_thousand	0.014476
3	gdp_per_capita	0.001788
4	population_density	0.000466

	location	date	cardiovasc_death_rate	diabetes_prevalence	female_smokers	male_smokers	life_expectancy	aged_65_older	median_age	Mortality Rate
7310	Finland	1/29/2020	153.507	5.76	18.3	22.6	81.91	21.228	42.8	0.00000
7311	Finland	1/30/2020	153.507	5.76	18.3	22.6	81.91	21.228	42.8	0.00000
7312	Finland	1/31/2020	153.507	5.76	18.3	22.6	81.91	21.228	42.8	0.00000
7313	Finland	2/1/2020	153.507	5.76	18.3	22.6	81.91	21.228	42.8	0.00000
7314	Finland	2/2/2020	153.507	5.76	18.3	22.6	81.91	21.228	42.8	0.00000
...	...	...	...	...	...	...	...	...	...	...
21942	Iceland	12/25/2022	117.992	5.31	14.3	15.2	82.99	14.431	37.3	0.11011
21943	Iceland	12/26/2022	117.992	5.31	14.3	15.2	82.99	14.431	37.3	0.11011
21944	Iceland	12/27/2022	117.992	5.31	14.3	15.2	82.99	14.431	37.3	0.11011
21945	Iceland	12/28/2022	117.992	5.31	14.3	15.2	82.99	14.431	37.3	0.11011
21946	Iceland	12/29/2022	117.992	5.31	14.3	15.2	82.99	14.431	37.3	0.11011

	feature	importance
1	diabetes_prevalence	0.517316
0	cardiovasc_death_rate	0.432531
6	median_age	0.019175
5	aged_65_older	0.014394
2	female_smokers	0.011943
3	male_smokers	0.003277
4	life_expectancy	0.001363

	feature	importance
1	human_development_index	0.941978
0	hospital_beds_per_thousand	0.035166
2	extreme_poverty	0.014051
3	gdp_per_capita	0.006777
4	population_density	0.002029

	location	date	cardiovasc_death_rate	diabetes_prevalence	female_smokers	male_smokers	life_expectancy	aged_65_older	median_age	Mortality Rate
8376	France	1/24/2020	86.060	4.77	30.1	35.6	82.66	19.718	42.0	0.000000
8377	France	1/25/2020	86.060	4.77	30.1	35.6	82.66	19.718	42.0	0.000000
8378	France	1/26/2020	86.060	4.77	30.1	35.6	82.66	19.718	42.0	0.000000
8379	France	1/27/2020	86.060	4.77	30.1	35.6	82.66	19.718	42.0	0.000000
8380	France	1/28/2020	86.060	4.77	30.1	35.6	82.66	19.718	42.0	0.000000
...	...	...	...	...	...	...	...	...	...	...
23006	Italy	12/25/2022	113.151	4.78	19.8	27.8	83.51	23.021	47.9	0.735109
23007	Italy	12/26/2022	113.151	4.78	19.8	27.8	83.51	23.021	47.9	0.735109
23008	Italy	12/27/2022	113.151	4.78	19.8	27.8	83.51	23.021	47.9	0.735109
23009	Italy	12/28/2022	113.151	4.78	19.8	27.8	83.51	23.021	47.9	0.735109
23010	Italy	12/29/2022	113.151	4.78	19.8	27.8	83.51	23.021	47.9	0.735109

	feature	importance
1	diabetes_prevalence	0.953673
2	female_smokers	0.024054
0	cardiovasc_death_rate	0.010520
5	aged_65_older	0.004307
3	male_smokers	0.004017
6	median_age	0.002808
4	life_expectancy	0.000621

	feature	importance
1	human_development_index	0.966568
2	extreme_poverty	0.022584
0	hospital_beds_per_thousand	0.006094
3	gdp_per_capita	0.004111
4	population_density	0.000643

	location	date	cardiovasc_death_rate	diabetes_prevalence	female_smokers	male_smokers	life_expectancy	aged_65_older	median_age	Mortality Rate
9447	Netherlands	2/27/2020	109.361	5.29	24.4	27.3	82.28	18.779	43.2	0.000000
9448	Netherlands	2/28/2020	109.361	5.29	24.4	27.3	82.28	18.779	43.2	0.000000
9449	Netherlands	2/29/2020	109.361	5.29	24.4	27.3	82.28	18.779	43.2	0.000000
9450	Netherlands	3/1/2020	109.361	5.29	24.4	27.3	82.28	18.779	43.2	0.000000
9451	Netherlands	3/2/2020	109.361	5.29	24.4	27.3	82.28	18.779	43.2	0.000000
...	...	...	...	...	...	...	...	...	...	...
24069	Sweden	12/25/2022	133.982	4.79	18.8	18.9	82.80	19.985	41.0	0.811466
24070	Sweden	12/26/2022	133.982	4.79	18.8	18.9	82.80	19.985	41.0	0.811466
24071	Sweden	12/27/2022	133.982	4.79	18.8	18.9	82.80	19.985	41.0	0.811466
24072	Sweden	12/28/2022	133.982	4.79	18.8	18.9	82.80	19.985	41.0	0.811466
24073	Sweden	12/29/2022	133.982	4.79	18.8	18.9	82.80	19.985	41.0	0.816005

	feature	importance
1	diabetes_prevalence	0.973529
2	female_smokers	0.023056
3	male_smokers	0.001375
0	cardiovasc_death_rate	0.000910
5	aged_65_older	0.000438
4	life_expectancy	0.000347
6	median_age	0.000345

	feature	importance
1	human_development_index	0.974035
2	extreme_poverty	0.023848
3	gdp_per_capita	0.001661
4	population_density	0.000405
0	hospital_beds_per_thousand	0.000052

	location	date	cardiovasc_death_rate	diabetes_prevalence	female_smokers	male_smokers	life_expectancy	aged_65_older	median_age	Mortality Rate
10484	Portugal	3/1/2020	127.842	9.85	16.3	30.0	82.05	21.502	46.2	0.000000
10485	Portugal	3/2/2020	127.842	9.85	16.3	30.0	82.05	21.502	46.2	0.000000
10486	Portugal	3/3/2020	127.842	9.85	16.3	30.0	82.05	21.502	46.2	0.000000
10487	Portugal	3/4/2020	127.842	9.85	16.3	30.0	82.05	21.502	46.2	0.000000
10488	Portugal	3/5/2020	127.842	9.85	16.3	30.0	82.05	21.502	46.2	0.000000
...	...	...	...	...	...	...	...	...	...	...
25132	Spain	12/25/2022	99.403	7.17	27.4	31.4	83.56	19.436	45.5	0.855148
25133	Spain	12/26/2022	99.403	7.17	27.4	31.4	83.56	19.436	45.5	0.855148
25134	Spain	12/27/2022	99.403	7.17	27.4	31.4	83.56	19.436	45.5	0.855148
25135	Spain	12/28/2022	99.403	7.17	27.4	31.4	83.56	19.436	45.5	0.855148
25136	Spain	12/29/2022	99.403	7.17	27.4	31.4	83.56	19.436	45.5	0.855148

	feature	importance
1	diabetes_prevalence	0.569929
0	cardiovasc_death_rate	0.229154
5	aged_65_older	0.161755
2	female_smokers	0.033937
6	median_age	0.002516
3	male_smokers	0.002434
4	life_expectancy	0.000275

	feature	importance
1	human_development_index	0.941568
2	extreme_poverty	0.040873
0	hospital_beds_per_thousand	0.012181
3	gdp_per_capita	0.004690
4	population_density	0.000688